home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / r2l.lha / r2l / m2c / Parser.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  38KB  |  1,343 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Scanner
  4. #include "Scanner.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Positions
  8. #include "Positions.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Errors
  12. #include "Errors.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Strings
  16. #include "Strings.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_DynArray
  20. #include "DynArray.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Sets
  24. #include "Sets.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_System
  28. #include "System.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Strings
  32. #include "Strings.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_StringMem
  36. #include "StringMem.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Idents
  40. #include "Idents.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Texts
  44. #include "Texts.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_IO
  48. #include "IO.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_StdIO
  52. #include "StdIO.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_Errors
  56. #include "Errors.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_DefTable
  60. #include "DefTable.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_Parser
  64. #include "Parser.h"
  65. #endif
  66.  
  67. struct Parser_1 Parser_ParsTabName;
  68.  
  69. #define IdentUndefined    10
  70. #define ImproperUse    11
  71. #define IdentDefBefore    12
  72. #define Error    3
  73. #define C_1_String    7
  74. typedef struct S_1 {
  75.     Scanner_tScanAttribute Scan;
  76. } tParsAttribute;
  77. static Strings_tString string;
  78. static Idents_tIdent ANY;
  79. static DefTable_DefRange Definition;
  80. static BOOLEAN complement;
  81. static Texts_tText Export, Global, Local, Begin, C_2_Close, Default, Eof;
  82. static void WriteChar ARGS((CHAR Ch, BOOLEAN InClass));
  83. #define yyInitStackSize    100
  84. #define yyNoState    0
  85. #define yyFirstTerminal    0
  86. #define yyLastTerminal    38
  87. #define yyFirstSymbol    0
  88. #define yyLastSymbol    79
  89. #define yyTableMax    251
  90. #define yyNTableMax    114
  91. #define yyFirstReadState    1
  92. #define yyLastReadState    69
  93. #define yyFirstReadTermState    70
  94. #define yyLastReadTermState    96
  95. #define yyLastReadNontermState    111
  96. #define yyFirstReduceState    112
  97. #define yyLastReduceState    188
  98. #define yyStartState    1
  99. #define yyStopState    112
  100. #define yyFirstFinalState    yyFirstReadTermState
  101. #define yyLastState    yyLastReduceState
  102. typedef SHORTCARD yyTableElmt;
  103. typedef yyTableElmt yyTCombRange;
  104. typedef yyTableElmt yyNCombRange;
  105. typedef yyTableElmt yyStateRange;
  106. typedef yyTableElmt yyReadRange;
  107. typedef yyTableElmt yyReadReduceRange;
  108. typedef yyTableElmt yyReduceRange;
  109. typedef yyTableElmt yySymbolRange;
  110. typedef struct S_2 {
  111.     yyStateRange Check, Next;
  112. } yyTCombType;
  113. typedef yyStateRange yyNCombType;
  114. typedef yyTCombType *yyTCombTypePtr;
  115. typedef yyNCombType *yyNCombTypePtr;
  116. typedef struct S_3 {
  117.     yyStateRange A[1000000 + 1];
  118. } *yyStackType;
  119. static struct S_4 {
  120.     yyTCombTypePtr A[yyLastReadState + 1];
  121. } yyTBasePtr;
  122. static struct S_5 {
  123.     yyNCombTypePtr A[yyLastReadState + 1];
  124. } yyNBasePtr;
  125. static struct S_6 {
  126.     yyReadRange A[yyLastReadState + 1];
  127. } yyDefault;
  128. static struct S_7 {
  129.     yyTCombType A[yyTableMax + 1];
  130. } yyTComb;
  131. static struct S_8 {
  132.     yyNCombType A[yyNTableMax - (yyLastTerminal + 1) + 1];
  133. } yyNComb;
  134. static struct S_9 {
  135.     yyTableElmt A[yyLastReduceState - yyFirstReduceState + 1];
  136. } yyLength;
  137. static struct S_10 {
  138.     yySymbolRange A[yyLastReduceState - yyFirstReduceState + 1];
  139. } yyLeftHandSide;
  140. static struct S_11 {
  141.     yySymbolRange A[yyLastReadState + 1];
  142. } yyContinuation;
  143. static struct S_12 {
  144.     yyReduceRange A[yyLastReadNontermState - yyFirstReadTermState + 1];
  145. } yyFinalToProd;
  146. static BOOLEAN yyIsInitialized;
  147. static System_tFile yyTableFile;
  148. static void Copy ARGS((CHAR Source[], LONGCARD , CHAR Target[], LONGCARD ));
  149. struct S_16 {
  150.     tParsAttribute A[1000000 + 1];
  151. };
  152. struct S_17 {
  153.     CHAR A[127 + 1];
  154. };
  155. static void ErrorRecovery ARGS((yySymbolRange *Terminal, yyStackType StateStack, LONGINT StackSize, LONGINT StackPtr));
  156. struct S_18 {
  157.     CHAR A[127 + 1];
  158. };
  159. static void ComputeContinuation ARGS((yyStackType Stack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *ContinueSet));
  160. static BOOLEAN IsContinuation ARGS((yySymbolRange Terminal, yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr));
  161. static void ComputeRestartPoints ARGS((yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *RestartSet));
  162. static yyStateRange Next ARGS((yyStateRange State, yySymbolRange Symbol));
  163. static void yyGetTables ARGS(());
  164. struct S_19 {
  165.     yyTCombRange A[yyLastReadState + 1];
  166. };
  167. struct S_20 {
  168.     yyNCombRange A[yyLastReadState + 1];
  169. };
  170. static CARDINAL yyGetTable ARGS((ADDRESS Address));
  171. static void yyErrorCheck ARGS((INTEGER ErrorCode, INTEGER Info));
  172. static void BeginParser ARGS(());
  173.  
  174.  
  175. static void WriteChar
  176. # ifdef __STDC__
  177. (CHAR Ch, BOOLEAN InClass)
  178. # else
  179. (Ch, InClass)
  180. CHAR Ch;
  181. BOOLEAN InClass;
  182. # endif
  183. {
  184.   if ('A' <= Ch && Ch <= 'Z' || 'a' <= Ch && Ch <= 'z' || '0' <= Ch && Ch <= '9') {
  185.     StdIO_WriteC(Ch);
  186.   } else {
  187.     switch (Ch) {
  188.     case '\n':;
  189.       StdIO_WriteS((STRING)"\\n", 2L);
  190.       break;
  191.     case '\t':;
  192.       StdIO_WriteS((STRING)"\\t", 2L);
  193.       break;
  194.     case ((CHAR)'\13'):;
  195.       StdIO_WriteS((STRING)"\\v", 2L);
  196.       break;
  197.     case '\b':;
  198.       StdIO_WriteS((STRING)"\\b", 2L);
  199.       break;
  200.     case '\r':;
  201.       StdIO_WriteS((STRING)"\\r", 2L);
  202.       break;
  203.     case '\f':;
  204.       StdIO_WriteS((STRING)"\\f", 2L);
  205.       break;
  206.     case '"':;
  207.       StdIO_WriteS((STRING)"\\\"", 2L);
  208.       break;
  209.     case ']':;
  210.       StdIO_WriteS((STRING)"\\]", 2L);
  211.       break;
  212.     case '.':;
  213.       StdIO_WriteS((STRING)"\\.", 2L);
  214.       break;
  215.     case '^':;
  216.       StdIO_WriteS((STRING)"\\^", 2L);
  217.       break;
  218.     case '-':;
  219.       StdIO_WriteS((STRING)"\\-", 2L);
  220.       break;
  221.     case '\\':;
  222.       StdIO_WriteS((STRING)"\\\\", 2L);
  223.       break;
  224.     default :
  225.       if (InClass) {
  226.         StdIO_WriteC(Ch);
  227.       } else {
  228.         StdIO_WriteC('"');
  229.         StdIO_WriteC(Ch);
  230.         StdIO_WriteC('"');
  231.       }
  232.       break;
  233.     }
  234.   }
  235. }
  236.  
  237. static void Copy
  238. # ifdef __STDC__
  239. (CHAR Source[], LONGCARD O_2, CHAR Target[], LONGCARD O_1)
  240. # else
  241. (Source, O_2, Target, O_1)
  242. CHAR Source[];
  243. LONGCARD O_2;
  244. CHAR Target[];
  245. LONGCARD O_1;
  246. # endif
  247. {
  248.   CARDINAL i, j;
  249.   OPEN_ARRAY_LOCALS
  250.  
  251.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(CHAR), 1)
  252.   COPY_OPEN_ARRAY(Source, O_2, CHAR)
  253.   if ((O_2 - 1) < (O_1 - 1)) {
  254.     j = (O_2 - 1);
  255.   } else {
  256.     j = (O_1 - 1);
  257.   }
  258.   {
  259.     LONGCARD B_1 = 0, B_2 = j;
  260.  
  261.     if (B_1 <= B_2)
  262.       for (i = B_1;; i += 1) {
  263.         Target[i] = Source[i];
  264.         if (i >= B_2) break;
  265.       }
  266.   }
  267.   if ((O_1 - 1) > j) {
  268.     Target[j + 1] = CHR(0);
  269.   }
  270.   FREE_OPEN_ARRAYS
  271. }
  272.  
  273. void Parser_TokenName
  274. # ifdef __STDC__
  275. (CARDINAL Token, CHAR Name[], LONGCARD O_3)
  276. # else
  277. (Token, Name, O_3)
  278. CARDINAL Token;
  279. CHAR Name[];
  280. LONGCARD O_3;
  281. # endif
  282. {
  283.   switch (Token) {
  284.   case 0:;
  285.     Copy((STRING)"_EndOfFile", 10L, Name, O_3);
  286.     break;
  287.   case 1:;
  288.     Copy((STRING)"Ident", 5L, Name, O_3);
  289.     break;
  290.   case 2:;
  291.     Copy((STRING)"Number", 6L, Name, O_3);
  292.     break;
  293.   case 3:;
  294.     Copy((STRING)"String", 6L, Name, O_3);
  295.     break;
  296.   case 4:;
  297.     Copy((STRING)"Char", 4L, Name, O_3);
  298.     break;
  299.   case 5:;
  300.     Copy((STRING)"TargetCode", 10L, Name, O_3);
  301.     break;
  302.   case 6:;
  303.     Copy((STRING)"GLOBAL", 6L, Name, O_3);
  304.     break;
  305.   case 7:;
  306.     Copy((STRING)"BEGIN", 5L, Name, O_3);
  307.     break;
  308.   case 8:;
  309.     Copy((STRING)"CLOSE", 5L, Name, O_3);
  310.     break;
  311.   case 9:;
  312.     Copy((STRING)"DEFINE", 6L, Name, O_3);
  313.     break;
  314.   case 10:;
  315.     Copy((STRING)"START", 5L, Name, O_3);
  316.     break;
  317.   case 11:;
  318.     Copy((STRING)"RULES", 5L, Name, O_3);
  319.     break;
  320.   case 12:;
  321.     Copy((STRING)".", 1L, Name, O_3);
  322.     break;
  323.   case 13:;
  324.     Copy((STRING)",", 1L, Name, O_3);
  325.     break;
  326.   case 14:;
  327.     Copy((STRING)"=", 1L, Name, O_3);
  328.     break;
  329.   case 15:;
  330.     Copy((STRING)":", 1L, Name, O_3);
  331.     break;
  332.   case 16:;
  333.     Copy((STRING)"/", 1L, Name, O_3);
  334.     break;
  335.   case 17:;
  336.     Copy((STRING)"|", 1L, Name, O_3);
  337.     break;
  338.   case 18:;
  339.     Copy((STRING)"+", 1L, Name, O_3);
  340.     break;
  341.   case 19:;
  342.     Copy((STRING)"-", 1L, Name, O_3);
  343.     break;
  344.   case 20:;
  345.     Copy((STRING)"*", 1L, Name, O_3);
  346.     break;
  347.   case 21:;
  348.     Copy((STRING)"?", 1L, Name, O_3);
  349.     break;
  350.   case 22:;
  351.     Copy((STRING)"(", 1L, Name, O_3);
  352.     break;
  353.   case 23:;
  354.     Copy((STRING)")", 1L, Name, O_3);
  355.     break;
  356.   case 24:;
  357.     Copy((STRING)"[", 1L, Name, O_3);
  358.     break;
  359.   case 25:;
  360.     Copy((STRING)"]", 1L, Name, O_3);
  361.     break;
  362.   case 26:;
  363.     Copy((STRING)"{", 1L, Name, O_3);
  364.     break;
  365.   case 27:;
  366.     Copy((STRING)"}", 1L, Name, O_3);
  367.     break;
  368.   case 28:;
  369.     Copy((STRING)"<", 1L, Name, O_3);
  370.     break;
  371.   case 29:;
  372.     Copy((STRING)">", 1L, Name, O_3);
  373.     break;
  374.   case 30:;
  375.     Copy((STRING)"NOT", 3L, Name, O_3);
  376.     break;
  377.   case 31:;
  378.     Copy((STRING)"LOCAL", 5L, Name, O_3);
  379.     break;
  380.   case 32:;
  381.     Copy((STRING)"EXPORT", 6L, Name, O_3);
  382.     break;
  383.   case 33:;
  384.     Copy((STRING)"#", 1L, Name, O_3);
  385.     break;
  386.   case 34:;
  387.     Copy((STRING)"EOF", 3L, Name, O_3);
  388.     break;
  389.   case 35:;
  390.     Copy((STRING)":-", 2L, Name, O_3);
  391.     break;
  392.   case 36:;
  393.     Copy((STRING)"DEFAULT", 7L, Name, O_3);
  394.     break;
  395.   case 37:;
  396.     Copy((STRING)"COMPL", 5L, Name, O_3);
  397.     break;
  398.   case 38:;
  399.     Copy((STRING)"SEQUENCE", 8L, Name, O_3);
  400.     break;
  401.   }
  402. }
  403.  
  404. CARDINAL Parser_Parser
  405. # ifdef __STDC__
  406. ()
  407. # else
  408. ()
  409. # endif
  410. {
  411.   yyStateRange yyState;
  412.   yySymbolRange yyTerminal;
  413.   yySymbolRange yyNonterminal;
  414.   yyTableElmt yyStackPtr;
  415.   LONGINT yyStateStackSize;
  416.   LONGINT yyAttrStackSize;
  417.   yyTableElmt yyShortStackSize;
  418.   yyStackType yyStateStack;
  419.   struct S_16 *yyAttributeStack;
  420.   tParsAttribute yySynAttribute;
  421.   Scanner_tScanAttribute yyRepairAttribute;
  422.   yySymbolRange yyRepairToken;
  423.   yyTCombTypePtr yyTCombPtr;
  424.   yyNCombTypePtr yyNCombPtr;
  425.   BOOLEAN yyIsRepairing;
  426.   CARDINAL yyErrorCount;
  427.   struct S_17 yyTokenString;
  428.  
  429.   BeginParser();
  430.   yyState = yyStartState;
  431.   yyTerminal = Scanner_GetToken();
  432.   yyStateStackSize = yyInitStackSize;
  433.   yyAttrStackSize = yyInitStackSize;
  434.   DynArray_MakeArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyStateRange));
  435.   DynArray_MakeArray((ADDRESS *)&yyAttributeStack, &yyAttrStackSize, (LONGINT)sizeof(tParsAttribute));
  436.   yyShortStackSize = yyStateStackSize - 1;
  437.   yyStackPtr = 0;
  438.   yyErrorCount = 0;
  439.   yyIsRepairing = FALSE;
  440.   for (;;) {
  441.     if (yyStackPtr >= yyShortStackSize) {
  442.       DynArray_ExtendArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyStateRange));
  443.       DynArray_ExtendArray((ADDRESS *)&yyAttributeStack, &yyAttrStackSize, (LONGINT)sizeof(tParsAttribute));
  444.       yyShortStackSize = yyStateStackSize - 1;
  445.     }
  446.     yyStateStack->A[yyStackPtr] = yyState;
  447.     for (;;) {
  448.       yyTCombPtr = (yyTCombTypePtr)((LONGCARD)yyTBasePtr.A[yyState] + yyTerminal * sizeof(yyTCombType));
  449.       if (yyTCombPtr->Check == yyState) {
  450.         yyState = yyTCombPtr->Next;
  451.         goto EXIT_2;
  452.       }
  453.       yyState = yyDefault.A[yyState];
  454.       if (yyState == yyNoState) {
  455.         yyState = yyStateStack->A[yyStackPtr];
  456.         if (yyIsRepairing) {
  457.           yyRepairToken = yyContinuation.A[yyState];
  458.           yyState = Next(yyState, yyRepairToken);
  459.           if (yyState <= yyLastReadTermState) {
  460.             Scanner_ErrorAttribute((LONGCARD)yyRepairToken, &yyRepairAttribute);
  461.             Parser_TokenName((LONGCARD)yyRepairToken, yyTokenString.A, 128L);
  462.             Errors_ErrorMessageI((LONGCARD)Errors_TokenInserted, (LONGCARD)Errors_Repair, Scanner_Attribute.Position, (LONGCARD)Errors_Array, ADR(yyTokenString));
  463.             if (yyState >= yyFirstFinalState) {
  464.               yyState = yyFinalToProd.A[yyState - 70];
  465.             }
  466.             INC(yyStackPtr);
  467.             yyAttributeStack->A[yyStackPtr].Scan = yyRepairAttribute;
  468.             yyStateStack->A[yyStackPtr] = yyState;
  469.           }
  470.           if (yyState >= yyFirstFinalState) {
  471.             goto EXIT_2;
  472.           }
  473.         } else {
  474.           INC(yyErrorCount);
  475.           ErrorRecovery(&yyTerminal, yyStateStack, yyStateStackSize, (LONGINT)yyStackPtr);
  476.           yyIsRepairing = TRUE;
  477.         }
  478.       }
  479.     } EXIT_2:;
  480.     if (yyState >= yyFirstFinalState) {
  481.       if (yyState <= yyLastReadTermState) {
  482.         INC(yyStackPtr);
  483.         yyAttributeStack->A[yyStackPtr].Scan = Scanner_Attribute;
  484.         yyTerminal = Scanner_GetToken();
  485.         yyIsRepairing = FALSE;
  486.       }
  487.       for (;;) {
  488.         switch (yyState) {
  489.         case 112:;
  490.           DynArray_ReleaseArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyTableElmt));
  491.           DynArray_ReleaseArray((ADDRESS *)&yyAttributeStack, &yyAttrStackSize, (LONGINT)sizeof(tParsAttribute));
  492.           return yyErrorCount;
  493.           break;
  494.         case 113:;
  495.         case 111:;
  496.           DEC1(yyStackPtr, 5);
  497.           yyNonterminal = 44;
  498.           StdIO_WriteNl();
  499.           StdIO_WriteS((STRING)"%%", 2L);
  500.           StdIO_WriteNl();
  501.           StdIO_WriteNl();
  502.           StdIO_WriteS((STRING)"void BeginScanner ()", 20L);
  503.           StdIO_WriteNl();
  504.           StdIO_WriteS((STRING)"{", 1L);
  505.           StdIO_WriteNl();
  506.           Texts_WriteText((System_tFile)IO_StdOutput, Begin);
  507.           StdIO_WriteS((STRING)"}", 1L);
  508.           StdIO_WriteNl();
  509.           StdIO_WriteNl();
  510.           StdIO_WriteS((STRING)"void CloseScanner ()", 20L);
  511.           StdIO_WriteNl();
  512.           StdIO_WriteS((STRING)"{", 1L);
  513.           StdIO_WriteNl();
  514.           Texts_WriteText((System_tFile)IO_StdOutput, C_2_Close);
  515.           StdIO_WriteS((STRING)"}", 1L);
  516.           StdIO_WriteNl();
  517.           break;
  518.         case 114:;
  519.           DEC1(yyStackPtr, 0);
  520.           yyNonterminal = 40;
  521.           StdIO_WriteS((STRING)"%{", 2L);
  522.           StdIO_WriteNl();
  523.           Texts_WriteText((System_tFile)IO_StdOutput, Export);
  524.           Texts_WriteText((System_tFile)IO_StdOutput, Global);
  525.           StdIO_WriteS((STRING)"%}", 2L);
  526.           StdIO_WriteNl();
  527.           StdIO_WriteNl();
  528.           break;
  529.         case 115:;
  530.           DEC1(yyStackPtr, 0);
  531.           yyNonterminal = 39;
  532.           break;
  533.         case 116:;
  534.         case 74:;
  535.           DEC1(yyStackPtr, 3);
  536.           yyNonterminal = 39;
  537.           Export = yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_5.Text;
  538.           break;
  539.         case 117:;
  540.         case 70:;
  541.           DEC1(yyStackPtr, 3);
  542.           yyNonterminal = 39;
  543.           Global = yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_5.Text;
  544.           break;
  545.         case 118:;
  546.         case 73:;
  547.           DEC1(yyStackPtr, 3);
  548.           yyNonterminal = 39;
  549.           Local = yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_5.Text;
  550.           break;
  551.         case 119:;
  552.         case 71:;
  553.           DEC1(yyStackPtr, 3);
  554.           yyNonterminal = 39;
  555.           Begin = yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_5.Text;
  556.           break;
  557.         case 120:;
  558.         case 72:;
  559.           DEC1(yyStackPtr, 3);
  560.           yyNonterminal = 39;
  561.           C_2_Close = yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_5.Text;
  562.           break;
  563.         case 121:;
  564.         case 76:;
  565.           DEC1(yyStackPtr, 3);
  566.           yyNonterminal = 39;
  567.           Default = yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_5.Text;
  568.           break;
  569.         case 122:;
  570.         case 75:;
  571.           DEC1(yyStackPtr, 3);
  572.           yyNonterminal = 39;
  573.           Eof = yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_5.Text;
  574.           StdIO_WriteS((STRING)"/*** sorry - cannot translate EOF ***/", 38L);
  575.           StdIO_WriteNl();
  576.           break;
  577.         case 123:;
  578.           DEC1(yyStackPtr, 0);
  579.           yyNonterminal = 41;
  580.           break;
  581.         case 124:;
  582.           DEC1(yyStackPtr, 2);
  583.           yyNonterminal = 41;
  584.           break;
  585.         case 125:;
  586.           DEC1(yyStackPtr, 0);
  587.           yyNonterminal = 42;
  588.           break;
  589.         case 126:;
  590.           DEC1(yyStackPtr, 3);
  591.           yyNonterminal = 42;
  592.           StdIO_WriteNl();
  593.           StdIO_WriteNl();
  594.           break;
  595.         case 127:;
  596.           DEC1(yyStackPtr, 0);
  597.           yyNonterminal = 46;
  598.           StdIO_WriteNl();
  599.           StdIO_WriteS((STRING)"%Start", 6L);
  600.           break;
  601.         case 128:;
  602.           DEC1(yyStackPtr, 3);
  603.           yyNonterminal = 43;
  604.           StdIO_WriteS((STRING)"\" \"    ;", 5L);
  605.           StdIO_WriteNl();
  606.           StdIO_WriteS((STRING)"\\t    ;", 4L);
  607.           StdIO_WriteNl();
  608.           StdIO_WriteS((STRING)"\\n    ;", 4L);
  609.           StdIO_WriteNl();
  610.           StdIO_WriteS((STRING)".    {", 3L);
  611.           Texts_WriteText((System_tFile)IO_StdOutput, Default);
  612.           StdIO_WriteS((STRING)"}", 1L);
  613.           StdIO_WriteNl();
  614.           break;
  615.         case 129:;
  616.           DEC1(yyStackPtr, 0);
  617.           yyNonterminal = 48;
  618.           StdIO_WriteS((STRING)"%%", 2L);
  619.           StdIO_WriteNl();
  620.           StdIO_WriteNl();
  621.           StdIO_WriteS((STRING)"%{", 2L);
  622.           StdIO_WriteNl();
  623.           Texts_WriteText((System_tFile)IO_StdOutput, Local);
  624.           StdIO_WriteS((STRING)"%}", 2L);
  625.           StdIO_WriteNl();
  626.           StdIO_WriteNl();
  627.           break;
  628.         case 130:;
  629.           DEC1(yyStackPtr, 0);
  630.           yyNonterminal = 45;
  631.           break;
  632.         case 131:;
  633.         case 100:;
  634.           DEC1(yyStackPtr, 2);
  635.           yyNonterminal = 45;
  636.           break;
  637.         case 132:;
  638.           DEC1(yyStackPtr, 0);
  639.           yyNonterminal = 49;
  640.           break;
  641.         case 133:;
  642.         case 107:;
  643.           DEC1(yyStackPtr, 2);
  644.           yyNonterminal = 49;
  645.           break;
  646.         case 134:;
  647.         case 103:;
  648.           DEC1(yyStackPtr, 1);
  649.           yyNonterminal = 47;
  650.           break;
  651.         case 135:;
  652.         case 102:;
  653.           DEC1(yyStackPtr, 2);
  654.           yyNonterminal = 47;
  655.           break;
  656.         case 136:;
  657.         case 101:;
  658.           DEC1(yyStackPtr, 3);
  659.           yyNonterminal = 47;
  660.           break;
  661.         case 137:;
  662.         case 89:;
  663.           DEC1(yyStackPtr, 1);
  664.           yyNonterminal = 52;
  665.           StdIO_WriteC(' ');
  666.           Idents_WriteIdent((System_tFile)IO_StdOutput, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Ident);
  667.           break;
  668.         case 138:;
  669.         case 104:;
  670.           DEC1(yyStackPtr, 1);
  671.           yyNonterminal = 54;
  672.           break;
  673.         case 139:;
  674.         case 106:;
  675.           DEC1(yyStackPtr, 3);
  676.           yyNonterminal = 54;
  677.           break;
  678.         case 140:;
  679.         case 105:;
  680.           DEC1(yyStackPtr, 4);
  681.           yyNonterminal = 54;
  682.           break;
  683.         case 141:;
  684.           DEC1(yyStackPtr, 0);
  685.           yyNonterminal = 56;
  686.           StdIO_WriteC(',');
  687.           break;
  688.         case 142:;
  689.           DEC1(yyStackPtr, 0);
  690.           yyNonterminal = 55;
  691.           StdIO_WriteC(',');
  692.           break;
  693.         case 143:;
  694.         case 90:;
  695.           DEC1(yyStackPtr, 1);
  696.           yyNonterminal = 53;
  697.           Idents_WriteIdent((System_tFile)IO_StdOutput, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Ident);
  698.           break;
  699.         case 144:;
  700.         case 88:;
  701.           DEC1(yyStackPtr, 5);
  702.           yyNonterminal = 50;
  703.           StdIO_WriteNl();
  704.           break;
  705.         case 145:;
  706.           DEC1(yyStackPtr, 0);
  707.           yyNonterminal = 57;
  708.           if (DefTable_GetDef(yyAttributeStack->A[yyStackPtr - 1].Scan.U_1.V_1.Ident) == DefTable_NoDef) {
  709.             DefTable_MakeIdentDef(yyAttributeStack->A[yyStackPtr - 1].Scan.U_1.V_1.Ident);
  710.           } else {
  711.             Idents_GetString(yyAttributeStack->A[yyStackPtr - 1].Scan.U_1.V_1.Ident, &string);
  712.             Errors_ErrorMessageI((LONGCARD)IdentDefBefore, (LONGCARD)Error, yyAttributeStack->A[yyStackPtr - 1].Scan.Position, (LONGCARD)C_1_String, ADR(string));
  713.           }
  714.           Idents_WriteIdent((System_tFile)IO_StdOutput, yyAttributeStack->A[yyStackPtr - 1].Scan.U_1.V_1.Ident);
  715.           StdIO_WriteC('\t');
  716.           break;
  717.         case 146:;
  718.         case 95:;
  719.           DEC1(yyStackPtr, 4);
  720.           yyNonterminal = 51;
  721.           Texts_WriteText((System_tFile)IO_StdOutput, yyAttributeStack->A[yyStackPtr + 4].Scan.U_1.V_5.Text);
  722.           StdIO_WriteC('}');
  723.           StdIO_WriteNl();
  724.           break;
  725.         case 147:;
  726.         case 96:;
  727.           DEC1(yyStackPtr, 4);
  728.           yyNonterminal = 51;
  729.           Texts_WriteText((System_tFile)IO_StdOutput, yyAttributeStack->A[yyStackPtr + 4].Scan.U_1.V_5.Text);
  730.           StdIO_WriteC('}');
  731.           StdIO_WriteNl();
  732.           break;
  733.         case 148:;
  734.           DEC1(yyStackPtr, 0);
  735.           yyNonterminal = 61;
  736.           StdIO_WriteS((STRING)"    {", 2L);
  737.           break;
  738.         case 149:;
  739.           DEC1(yyStackPtr, 0);
  740.           yyNonterminal = 60;
  741.           StdIO_WriteS((STRING)"    {", 2L);
  742.           break;
  743.         case 150:;
  744.         case 110:;
  745.           DEC1(yyStackPtr, 1);
  746.           yyNonterminal = 59;
  747.           break;
  748.         case 151:;
  749.         case 108:;
  750.           DEC1(yyStackPtr, 4);
  751.           yyNonterminal = 59;
  752.           break;
  753.         case 152:;
  754.           DEC1(yyStackPtr, 0);
  755.           yyNonterminal = 63;
  756.           StdIO_WriteS((STRING)"    |", 2L);
  757.           break;
  758.         case 153:;
  759.         case 109:;
  760.           DEC1(yyStackPtr, 5);
  761.           yyNonterminal = 62;
  762.           break;
  763.         case 154:;
  764.           DEC1(yyStackPtr, 0);
  765.           yyNonterminal = 64;
  766.           break;
  767.         case 155:;
  768.         case 92:;
  769.           DEC1(yyStackPtr, 4);
  770.           yyNonterminal = 64;
  771.           StdIO_WriteC('>');
  772.           break;
  773.         case 156:;
  774.         case 91:;
  775.           DEC1(yyStackPtr, 4);
  776.           yyNonterminal = 64;
  777.           StdIO_WriteS((STRING)"/*** sorry - cannot translate NOT ***/", 38L);
  778.           StdIO_WriteNl();
  779.           break;
  780.         case 157:;
  781.           DEC1(yyStackPtr, 0);
  782.           yyNonterminal = 68;
  783.           StdIO_WriteC('<');
  784.           break;
  785.         case 158:;
  786.           DEC1(yyStackPtr, 0);
  787.           yyNonterminal = 65;
  788.           break;
  789.         case 159:;
  790.         case 93:;
  791.           DEC1(yyStackPtr, 1);
  792.           yyNonterminal = 65;
  793.           StdIO_WriteC('^');
  794.           break;
  795.         case 160:;
  796.           DEC1(yyStackPtr, 0);
  797.           yyNonterminal = 66;
  798.           break;
  799.         case 161:;
  800.           DEC1(yyStackPtr, 3);
  801.           yyNonterminal = 66;
  802.           break;
  803.         case 162:;
  804.           DEC1(yyStackPtr, 0);
  805.           yyNonterminal = 69;
  806.           StdIO_WriteC('/');
  807.           break;
  808.         case 163:;
  809.           DEC1(yyStackPtr, 0);
  810.           yyNonterminal = 67;
  811.           break;
  812.         case 164:;
  813.         case 94:;
  814.           DEC1(yyStackPtr, 1);
  815.           yyNonterminal = 67;
  816.           StdIO_WriteC('$');
  817.           break;
  818.         case 165:;
  819.           DEC1(yyStackPtr, 4);
  820.           yyNonterminal = 58;
  821.           break;
  822.         case 166:;
  823.           DEC1(yyStackPtr, 2);
  824.           yyNonterminal = 58;
  825.           break;
  826.         case 167:;
  827.         case 80:;
  828.           DEC1(yyStackPtr, 2);
  829.           yyNonterminal = 58;
  830.           StdIO_WriteC('+');
  831.           break;
  832.         case 168:;
  833.         case 81:;
  834.           DEC1(yyStackPtr, 2);
  835.           yyNonterminal = 58;
  836.           StdIO_WriteC('*');
  837.           break;
  838.         case 169:;
  839.         case 82:;
  840.           DEC1(yyStackPtr, 2);
  841.           yyNonterminal = 58;
  842.           StdIO_WriteC('?');
  843.           break;
  844.         case 170:;
  845.         case 84:;
  846.           DEC1(yyStackPtr, 4);
  847.           yyNonterminal = 58;
  848.           StdIO_WriteC('{');
  849.           StdIO_WriteI((LONGINT)yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_2.Number, 0L);
  850.           StdIO_WriteC(',');
  851.           StdIO_WriteI((LONGINT)yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_2.Number, 0L);
  852.           StdIO_WriteC('}');
  853.           break;
  854.         case 171:;
  855.         case 83:;
  856.           DEC1(yyStackPtr, 6);
  857.           yyNonterminal = 58;
  858.           StdIO_WriteC('{');
  859.           StdIO_WriteI((LONGINT)yyAttributeStack->A[yyStackPtr + 3].Scan.U_1.V_2.Number, 0L);
  860.           StdIO_WriteC(',');
  861.           StdIO_WriteI((LONGINT)yyAttributeStack->A[yyStackPtr + 5].Scan.U_1.V_2.Number, 0L);
  862.           StdIO_WriteC('}');
  863.           break;
  864.         case 172:;
  865.         case 87:;
  866.           DEC1(yyStackPtr, 4);
  867.           yyNonterminal = 58;
  868.           StdIO_WriteC(')');
  869.           break;
  870.         case 173:;
  871.         case 99:;
  872.           DEC1(yyStackPtr, 2);
  873.           yyNonterminal = 58;
  874.           break;
  875.         case 174:;
  876.         case 79:;
  877.           DEC1(yyStackPtr, 1);
  878.           yyNonterminal = 58;
  879.           WriteChar(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_4.Ch, FALSE);
  880.           break;
  881.         case 175:;
  882.         case 77:;
  883.           DEC1(yyStackPtr, 1);
  884.           yyNonterminal = 58;
  885.           Definition = DefTable_GetDef(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Ident);
  886.           if (Definition != DefTable_NoDef) {
  887.             if (DefTable_GetKind(Definition) == DefTable_Ident) {
  888.               StdIO_WriteC('{');
  889.               Idents_WriteIdent((System_tFile)IO_StdOutput, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Ident);
  890.               StdIO_WriteC('}');
  891.             } else {
  892.               Idents_GetString(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Ident, &string);
  893.               Errors_ErrorMessageI((LONGCARD)ImproperUse, (LONGCARD)Error, yyAttributeStack->A[yyStackPtr + 1].Scan.Position, (LONGCARD)C_1_String, ADR(string));
  894.             }
  895.           } else {
  896.             if (yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Ident == ANY) {
  897.               StdIO_WriteC('.');
  898.             } else {
  899.               Idents_WriteIdent((System_tFile)IO_StdOutput, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_1.Ident);
  900.             }
  901.           }
  902.           break;
  903.         case 176:;
  904.         case 78:;
  905.           DEC1(yyStackPtr, 1);
  906.           yyNonterminal = 58;
  907.           StdIO_WriteC('"');
  908.           StringMem_WriteString((System_tFile)IO_StdOutput, yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_3.String);
  909.           StdIO_WriteC('"');
  910.           break;
  911.         case 177:;
  912.           DEC1(yyStackPtr, 0);
  913.           yyNonterminal = 71;
  914.           StdIO_WriteC('(');
  915.           break;
  916.         case 178:;
  917.           DEC1(yyStackPtr, 0);
  918.           yyNonterminal = 70;
  919.           StdIO_WriteC('|');
  920.           break;
  921.         case 179:;
  922.           DEC1(yyStackPtr, 0);
  923.           yyNonterminal = 72;
  924.           complement = FALSE;
  925.           break;
  926.         case 180:;
  927.         case 98:;
  928.           DEC1(yyStackPtr, 3);
  929.           yyNonterminal = 73;
  930.           break;
  931.         case 181:;
  932.         case 86:;
  933.           DEC1(yyStackPtr, 4);
  934.           yyNonterminal = 73;
  935.           StdIO_WriteC(']');
  936.           break;
  937.         case 182:;
  938.           DEC1(yyStackPtr, 0);
  939.           yyNonterminal = 75;
  940.           StdIO_WriteC('[');
  941.           if (complement) {
  942.             StdIO_WriteC('^');
  943.           }
  944.           break;
  945.         case 183:;
  946.           DEC1(yyStackPtr, 0);
  947.           yyNonterminal = 74;
  948.           complement = !complement;
  949.           break;
  950.         case 184:;
  951.           DEC1(yyStackPtr, 0);
  952.           yyNonterminal = 76;
  953.           break;
  954.         case 185:;
  955.         case 97:;
  956.           DEC1(yyStackPtr, 2);
  957.           yyNonterminal = 76;
  958.           break;
  959.         case 186:;
  960.           DEC1(yyStackPtr, 1);
  961.           yyNonterminal = 77;
  962.           WriteChar(yyAttributeStack->A[yyStackPtr + 1].Scan.U_1.V_4.Ch, TRUE);
  963.           break;
  964.         case 187:;
  965.         case 85:;
  966.           DEC1(yyStackPtr, 4);
  967.           yyNonterminal = 77;
  968.           WriteChar(yyAttributeStack->A[yyStackPtr + 4].Scan.U_1.V_4.Ch, TRUE);
  969.           break;
  970.         case 188:;
  971.           DEC1(yyStackPtr, 0);
  972.           yyNonterminal = 78;
  973.           WriteChar(yyAttributeStack->A[yyStackPtr - 1].Scan.U_1.V_4.Ch, TRUE);
  974.           StdIO_WriteC('-');
  975.           break;
  976.         }
  977.         yyNCombPtr = (yyNCombTypePtr)((LONGCARD)yyNBasePtr.A[yyStateStack->A[yyStackPtr]] + yyNonterminal * sizeof(yyNCombType));
  978.         yyState = *yyNCombPtr;
  979.         INC(yyStackPtr);
  980.         yyAttributeStack->A[yyStackPtr] = yySynAttribute;
  981.         if (yyState < yyFirstFinalState) {
  982.           goto EXIT_3;
  983.         }
  984.       } EXIT_3:;
  985.     } else {
  986.       INC(yyStackPtr);
  987.       yyAttributeStack->A[yyStackPtr].Scan = Scanner_Attribute;
  988.       yyTerminal = Scanner_GetToken();
  989.       yyIsRepairing = FALSE;
  990.     }
  991.   } EXIT_1:;
  992. }
  993.  
  994. static void ErrorRecovery
  995. # ifdef __STDC__
  996. (yySymbolRange *Terminal, yyStackType StateStack, LONGINT StackSize, LONGINT StackPtr)
  997. # else
  998. (Terminal, StateStack, StackSize, StackPtr)
  999. yySymbolRange *Terminal;
  1000. yyStackType StateStack;
  1001. LONGINT StackSize;
  1002. LONGINT StackPtr;
  1003. # endif
  1004. {
  1005.   BOOLEAN TokensSkipped;
  1006.   Sets_tSet ContinueSet;
  1007.   Sets_tSet RestartSet;
  1008.   yySymbolRange Token;
  1009.   struct S_18 TokenArray;
  1010.   Strings_tString TokenString;
  1011.   Strings_tString ContinueString;
  1012.  
  1013.   Errors_ErrorMessage((LONGCARD)Errors_SyntaxError, (LONGCARD)Errors_Error, Scanner_Attribute.Position);
  1014.   Sets_MakeSet(&ContinueSet, (LONGCARD)yyLastTerminal);
  1015.   ComputeContinuation(StateStack, StackSize, StackPtr, &ContinueSet);
  1016.   Strings_AssignEmpty(&ContinueString);
  1017.   {
  1018.     yySymbolRange B_3 = Sets_Minimum(&ContinueSet), B_4 = Sets_Maximum(&ContinueSet);
  1019.  
  1020.     if (B_3 <= B_4)
  1021.       for (Token = B_3;; Token += 1) {
  1022.         if (Sets_IsElement((LONGCARD)Token, &ContinueSet)) {
  1023.           Parser_TokenName((LONGCARD)Token, TokenArray.A, 128L);
  1024.           Strings_ArrayToString(TokenArray.A, 128L, &TokenString);
  1025.           if (Strings_Length(&ContinueString) + Strings_Length(&TokenString) + 1 <= Strings_cMaxStrLength) {
  1026.             Strings_Concatenate(&ContinueString, &TokenString);
  1027.             Strings_Append(&ContinueString, ' ');
  1028.           }
  1029.         }
  1030.         if (Token >= B_4) break;
  1031.       }
  1032.   }
  1033.   Errors_ErrorMessageI((LONGCARD)Errors_ExpectedTokens, (LONGCARD)Errors_Information, Scanner_Attribute.Position, (LONGCARD)Errors_String, ADR(ContinueString));
  1034.   Sets_ReleaseSet(&ContinueSet);
  1035.   Sets_MakeSet(&RestartSet, (LONGCARD)yyLastTerminal);
  1036.   ComputeRestartPoints(StateStack, StackSize, StackPtr, &RestartSet);
  1037.   TokensSkipped = FALSE;
  1038.   while (!Sets_IsElement((LONGCARD)(*Terminal), &RestartSet)) {
  1039.     *Terminal = Scanner_GetToken();
  1040.     TokensSkipped = TRUE;
  1041.   }
  1042.   Sets_ReleaseSet(&RestartSet);
  1043.   if (TokensSkipped) {
  1044.     Errors_ErrorMessage((LONGCARD)Errors_RestartPoint, (LONGCARD)Errors_Information, Scanner_Attribute.Position);
  1045.   }
  1046. }
  1047.  
  1048. static void ComputeContinuation
  1049. # ifdef __STDC__
  1050. (yyStackType Stack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *ContinueSet)
  1051. # else
  1052. (Stack, StackSize, StackPtr, ContinueSet)
  1053. yyStackType Stack;
  1054. LONGINT StackSize;
  1055. LONGINT StackPtr;
  1056. Sets_tSet *ContinueSet;
  1057. # endif
  1058. {
  1059.   yySymbolRange Terminal;
  1060.  
  1061.   Sets_AssignEmpty(ContinueSet);
  1062.   for (Terminal = yyFirstTerminal; Terminal <= yyLastTerminal; Terminal += 1) {
  1063.     if (IsContinuation(Terminal, Stack, StackSize, StackPtr)) {
  1064.       Sets_Include(ContinueSet, (LONGCARD)Terminal);
  1065.     }
  1066.   }
  1067. }
  1068.  
  1069. static BOOLEAN IsContinuation
  1070. # ifdef __STDC__
  1071. (yySymbolRange Terminal, yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr)
  1072. # else
  1073. (Terminal, ParseStack, StackSize, StackPtr)
  1074. yySymbolRange Terminal;
  1075. yyStackType ParseStack;
  1076. LONGINT StackSize;
  1077. LONGINT StackPtr;
  1078. # endif
  1079. {
  1080.   LONGINT State;
  1081.   yySymbolRange Nonterminal;
  1082.   yyStackType Stack;
  1083.  
  1084.   DynArray_MakeArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1085.   {
  1086.     LONGINT B_5 = 0, B_6 = StackPtr;
  1087.  
  1088.     if (B_5 <= B_6)
  1089.       for (State = B_5;; State += 1) {
  1090.         Stack->A[State] = ParseStack->A[State];
  1091.         if (State >= B_6) break;
  1092.       }
  1093.   }
  1094.   State = Stack->A[StackPtr];
  1095.   for (;;) {
  1096.     Stack->A[StackPtr] = State;
  1097.     State = Next((yyStateRange)State, Terminal);
  1098.     if (State == yyNoState) {
  1099.       DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1100.       return FALSE;
  1101.     }
  1102.     if (State <= yyLastReadTermState) {
  1103.       DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1104.       return TRUE;
  1105.     }
  1106.     for (;;) {
  1107.       if (State == yyStopState) {
  1108.         DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1109.         return TRUE;
  1110.       } else {
  1111.         DEC1(StackPtr, yyLength.A[State - 112]);
  1112.         Nonterminal = yyLeftHandSide.A[State - 112];
  1113.       }
  1114.       State = Next(Stack->A[StackPtr], Nonterminal);
  1115.       if (StackPtr >= StackSize) {
  1116.         DynArray_ExtendArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1117.       }
  1118.       INC(StackPtr);
  1119.       if (State < yyFirstFinalState) {
  1120.         goto EXIT_5;
  1121.       }
  1122.       State = yyFinalToProd.A[State - 70];
  1123.     } EXIT_5:;
  1124.   } EXIT_4:;
  1125. }
  1126.  
  1127. static void ComputeRestartPoints
  1128. # ifdef __STDC__
  1129. (yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *RestartSet)
  1130. # else
  1131. (ParseStack, StackSize, StackPtr, RestartSet)
  1132. yyStackType ParseStack;
  1133. LONGINT StackSize;
  1134. LONGINT StackPtr;
  1135. Sets_tSet *RestartSet;
  1136. # endif
  1137. {
  1138.   yyStackType Stack;
  1139.   LONGINT State;
  1140.   yySymbolRange Nonterminal;
  1141.   Sets_tSet ContinueSet;
  1142.  
  1143.   DynArray_MakeArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1144.   {
  1145.     LONGINT B_7 = 0, B_8 = StackPtr;
  1146.  
  1147.     if (B_7 <= B_8)
  1148.       for (State = B_7;; State += 1) {
  1149.         Stack->A[State] = ParseStack->A[State];
  1150.         if (State >= B_8) break;
  1151.       }
  1152.   }
  1153.   Sets_MakeSet(&ContinueSet, (LONGCARD)yyLastTerminal);
  1154.   Sets_AssignEmpty(RestartSet);
  1155.   State = Stack->A[StackPtr];
  1156.   for (;;) {
  1157.     if (StackPtr >= StackSize) {
  1158.       DynArray_ExtendArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1159.     }
  1160.     Stack->A[StackPtr] = State;
  1161.     ComputeContinuation(Stack, StackSize, StackPtr, &ContinueSet);
  1162.     Sets_Union(RestartSet, ContinueSet);
  1163.     State = Next((yyStateRange)State, yyContinuation.A[State]);
  1164.     if (State >= yyFirstFinalState) {
  1165.       if (State <= yyLastReadTermState) {
  1166.         INC(StackPtr);
  1167.         State = yyFinalToProd.A[State - 70];
  1168.       }
  1169.       for (;;) {
  1170.         if (State == yyStopState) {
  1171.           DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1172.           Sets_ReleaseSet(&ContinueSet);
  1173.           return;
  1174.         } else {
  1175.           DEC1(StackPtr, yyLength.A[State - 112]);
  1176.           Nonterminal = yyLeftHandSide.A[State - 112];
  1177.         }
  1178.         State = Next(Stack->A[StackPtr], Nonterminal);
  1179.         INC(StackPtr);
  1180.         if (State < yyFirstFinalState) {
  1181.           goto EXIT_7;
  1182.         }
  1183.         State = yyFinalToProd.A[State - 70];
  1184.       } EXIT_7:;
  1185.     } else {
  1186.       INC(StackPtr);
  1187.     }
  1188.   } EXIT_6:;
  1189. }
  1190.  
  1191. static yyStateRange Next
  1192. # ifdef __STDC__
  1193. (yyStateRange State, yySymbolRange Symbol)
  1194. # else
  1195. (State, Symbol)
  1196. yyStateRange State;
  1197. yySymbolRange Symbol;
  1198. # endif
  1199. {
  1200.   yyTCombTypePtr TCombPtr;
  1201.   yyNCombTypePtr NCombPtr;
  1202.  
  1203.   if (Symbol <= yyLastTerminal) {
  1204.     for (;;) {
  1205.       TCombPtr = (yyTCombTypePtr)((LONGCARD)yyTBasePtr.A[State] + Symbol * sizeof(yyTCombType));
  1206.       if (TCombPtr->Check != State) {
  1207.         State = yyDefault.A[State];
  1208.         if (State == yyNoState) {
  1209.           return yyNoState;
  1210.         }
  1211.       } else {
  1212.         return TCombPtr->Next;
  1213.       }
  1214.     } EXIT_8:;
  1215.   } else {
  1216.     NCombPtr = (yyNCombTypePtr)((LONGCARD)yyNBasePtr.A[State] + Symbol * sizeof(yyNCombType));
  1217.     return *NCombPtr;
  1218.   }
  1219. }
  1220.  
  1221. static void yyGetTables
  1222. # ifdef __STDC__
  1223. ()
  1224. # else
  1225. ()
  1226. # endif
  1227. {
  1228.   CARDINAL BlockSize, j, n;
  1229.   yyStateRange State;
  1230.   struct S_19 TBase;
  1231.   struct S_20 NBase;
  1232.  
  1233.   BlockSize = 64000 / sizeof(yyTCombType);
  1234.   yyTableFile = OpenInput(Parser_ParsTabName.A, 129L);
  1235.   yyErrorCheck((LONGINT)Errors_OpenParseTable, yyTableFile);
  1236.   if (yyGetTable(ADR(TBase)) / sizeof(yyTCombRange) - 1 != yyLastReadState || yyGetTable(ADR(NBase)) / sizeof(yyNCombRange) - 1 != yyLastReadState || yyGetTable(ADR(yyDefault)) / sizeof(yyReadRange) - 1 != yyLastReadState || yyGetTable(ADR(yyNComb)) / sizeof(yyNCombType) != yyNTableMax - yyLastTerminal || yyGetTable(ADR(yyLength)) / sizeof(yyTableElmt) - 1 != yyLastReduceState - yyFirstReduceState || yyGetTable(ADR(yyLeftHandSide)) / sizeof(yySymbolRange) - 1 != yyLastReduceState - yyFirstReduceState || yyGetTable(ADR(yyContinuation)) / sizeof(yySymbolRange) - 1 != yyLastReadState || yyGetTable(ADR(yyFinalToProd)) / sizeof(yyReduceRange) - 1 != yyLastReadNontermState - yyFirstReadTermState) {
  1237.     Errors_ErrorMessage((LONGCARD)Errors_WrongParseTable, (LONGCARD)Errors_Fatal, Positions_NoPosition);
  1238.   }
  1239.   n = 0;
  1240.   j = 0;
  1241.   while (j <= yyTableMax) {
  1242.     INC1(n, yyGetTable(ADR(yyTComb.A[j])) / sizeof(yyTCombType));
  1243.     INC1(j, BlockSize);
  1244.   }
  1245.   if (n != yyTableMax + 1) {
  1246.     Errors_ErrorMessage((LONGCARD)Errors_WrongParseTable, (LONGCARD)Errors_Fatal, Positions_NoPosition);
  1247.   }
  1248.   Close(yyTableFile);
  1249.   for (State = 1; State <= yyLastReadState; State += 1) {
  1250.     yyTBasePtr.A[State] = (yyTCombTypePtr)ADR(yyTComb.A[TBase.A[State]]);
  1251.   }
  1252.   for (State = 1; State <= yyLastReadState; State += 1) {
  1253.     yyNBasePtr.A[State] = (yyNCombTypePtr)ADR(yyNComb.A[NBase.A[State] - 39]);
  1254.   }
  1255. }
  1256.  
  1257. static CARDINAL yyGetTable
  1258. # ifdef __STDC__
  1259. (ADDRESS Address)
  1260. # else
  1261. (Address)
  1262. ADDRESS Address;
  1263. # endif
  1264. {
  1265.   INTEGER N;
  1266.   yyTableElmt Length;
  1267.  
  1268.   N = Read(yyTableFile, ADR(Length), (LONGCARD)sizeof(yyTableElmt));
  1269.   yyErrorCheck((LONGINT)Errors_ReadParseTable, N);
  1270.   N = Read(yyTableFile, Address, (LONGCARD)Length);
  1271.   yyErrorCheck((LONGINT)Errors_ReadParseTable, N);
  1272.   return Length;
  1273. }
  1274.  
  1275. static void yyErrorCheck
  1276. # ifdef __STDC__
  1277. (INTEGER ErrorCode, INTEGER Info)
  1278. # else
  1279. (ErrorCode, Info)
  1280. INTEGER ErrorCode;
  1281. INTEGER Info;
  1282. # endif
  1283. {
  1284.   INTEGER ErrNo;
  1285.  
  1286.   if (Info < 0) {
  1287.     ErrNo = ErrNum();
  1288.     Errors_ErrorMessageI((LONGCARD)ErrorCode, (LONGCARD)Errors_Fatal, Positions_NoPosition, (LONGCARD)Errors_Integer, ADR(ErrNo));
  1289.   }
  1290. }
  1291.  
  1292. static void BeginParser
  1293. # ifdef __STDC__
  1294. ()
  1295. # else
  1296. ()
  1297. # endif
  1298. {
  1299.   Strings_ArrayToString((STRING)"ANY", 3L, &string);
  1300.   ANY = Idents_MakeIdent(&string);
  1301.   if (!yyIsInitialized) {
  1302.     yyIsInitialized = TRUE;
  1303.     yyGetTables();
  1304.   }
  1305. }
  1306.  
  1307. void Parser_CloseParser
  1308. # ifdef __STDC__
  1309. ()
  1310. # else
  1311. ()
  1312. # endif
  1313. {
  1314. }
  1315.  
  1316. void BEGIN_Parser()
  1317. {
  1318.   static BOOLEAN has_been_called = FALSE;
  1319.  
  1320.   if (!has_been_called) {
  1321.     has_been_called = TRUE;
  1322.  
  1323.     BEGIN_Scanner();
  1324.     BEGIN_Positions();
  1325.     BEGIN_Errors();
  1326.     BEGIN_Strings();
  1327.     BEGIN_DynArray();
  1328.     BEGIN_Sets();
  1329.     BEGIN_System();
  1330.     BEGIN_Strings();
  1331.     BEGIN_StringMem();
  1332.     BEGIN_Idents();
  1333.     BEGIN_Texts();
  1334.     BEGIN_IO();
  1335.     BEGIN_StdIO();
  1336.     BEGIN_Errors();
  1337.     BEGIN_DefTable();
  1338.  
  1339.     yyIsInitialized = FALSE;
  1340.     (void)strncpy((char *)Parser_ParsTabName.A, "Parser.Tab", sizeof(Parser_ParsTabName.A));
  1341.   }
  1342. }
  1343.